import plugin from '../../lib/plugins/plugin.js'
import common from '../../lib/common/common.js'
import { segment } from 'oicq'
import lodash from 'lodash'
import cfg from '../../lib/config/config.js'
import fs from 'fs';
import YAML from "yaml";
import puppeteer from '../../lib/puppeteer/puppeteer.js'

/* 

    去掉了骂人词汇和违禁词,不然会违规
    请自行添加违禁词
    用这个js的话处理方式别选2

*/

let path = process.cwd().replace(/\\/g, '/')

await init()

let YamlReader = await import('../../resources/xiangcai/config.js')
YamlReader = YamlReader.default

let config = new YamlReader(path + '/resources/xiangcai/config.yaml', true)

await checkVersion()

export class example extends plugin {
  constructor() {
    super({
      name: '检测到骂人自动退群',
      dsc: '检测到骂人自动退群',
      event: 'message',
      priority: -114514,
      rule: [
        {
          /** 命令正则匹配 */
          reg: '^#香菜(违禁词|全局违禁词|禁用群聊|全局群聊|私聊通行字符)(添加|删除)(.+)$',
          /** 执行方法 */
          fnc: 'modify2',
        },
        {
          /** 命令正则匹配 */
          reg: '^.*$',
          /** 执行方法 */
          fnc: 'fuck',
          log: false
        },
        {
          /** 命令正则匹配 */
          reg: '^#香菜设置(默认名字|全局|通知|骂人at|骂人通知|禁言消息at|删好友|拉黑)(开启|关闭)$',
          /** 执行方法 */
          fnc: 'modify1',
        },
        {
          /** 命令正则匹配 */
          reg: '^#香菜设置(机器人名字|禁言消息|私聊消息)(.*)$',
          /** 执行方法 */
          fnc: 'modify3',
        },
        {
          /** 命令正则匹配 */
          reg: '^#香菜设置(全局处理|处理|处理二|处理三|次数|私聊次数|骂人类型|骂人撤回|禁言时间|禁言消息撤回)([0-9]+)$',
          /** 执行方法 */
          fnc: 'modify4',
        },
        {
          /** 命令正则匹配 */
          reg: '^#香菜(违禁词|全局违禁词|禁用群聊|全局群聊|私聊通行字符)列表$',
          /** 执行方法 */
          fnc: 'list',
        },
        {
          /** 命令正则匹配 */
          reg: '^#香菜(设置|帮助)$',
          /** 执行方法 */
          fnc: 'set',
        },
        {
          /** 命令正则匹配 */
          reg: '^#香菜清除群次数([0-9]+)$',
          /** 执行方法 */
          fnc: 'clear',
        },
        {
          /** 命令正则匹配 */
          reg: '^#香菜查询群次数([0-9]+)$',
          /** 执行方法 */
          fnc: 'query',
        },
      ]
    })
    this.otherPath = process.cwd().replace(/\\/g, '/') + '/config/config/other.yaml'
  }

  async clear(e) {
    if (!e.isMaster) {
      return false
    }
    let reg = new RegExp('^#香菜清除群次数([0-9]+)$')
    let group = reg.exec(e.msg)[1]
    let i = await redis.get(`Yunzai:fuck:group:${e.group_id}`)
    await redis.del(`Yunzai:fuck:group:${e.group_id}`)
    e.reply(`群:${group}次数:${i}\n清除成功`)
    return true
  }

  async query(e) {
    if (!e.isMaster) {
      return false
    }
    let reg = new RegExp('^#香菜查询群次数([0-9]+)$')
    let group = reg.exec(e.msg)[1]
    let i = await redis.get(`Yunzai:fuck:group:${group}`) || 0
    e.reply(`群:${group}次数:${i}`)
    return true
  }

  async set(e) {
    if (!e.isMaster) {
      return false
    }
    const setList = await this.getSetList()
    let img = await puppeteer.screenshot('help', {
      tplFile: path + '/resources/xiangcai/set.html',
      pluResPath: path,
      setList: setList,
      version: '1.8'
    })
    e.reply(img)
    return true
  }

  async list(e) {
    if (!e.isMaster) {
      return false
    }
    let reg = new RegExp('^#香菜(违禁词|全局违禁词|禁用群聊|全局群聊|私聊通行字符)列表$')
    let title = reg.exec(e.msg)[1]
    let titleList = ['违禁词', '全局违禁词', '禁用群聊', '全局群聊', '私聊通行字符']
    let titleKey = ['arr', 'rangeArr', 'notGroup', 'rangeGroup', 'privateAdopt']
    let msg = [`${title}列表:\n`]
    for (let i = 0; i < titleList.length; i++) {
      if (title == titleList[i]) {
        let arr = await this.getList(titleKey[i])
        if (Array.isArray(arr)) {
          msg.push(arr.join('\n'))
        } else {
          msg.push('无')
        }
        break
      }
    }
    e.reply(msg)
    return true
  }

  async getList(key) {
    return config.get(key)
  }


  async modify1(e) {
    if (!e.isMaster) {
      return false
    }
    let reg = new RegExp('^#香菜设置(默认名字|全局|通知|骂人at|骂人通知|禁言消息at|删好友|拉黑)(开启|关闭)$')
    let title = reg.exec(e.msg)[1]
    let value = reg.exec(e.msg)[2]
    let titleList = ['默认名字', '全局', '通知', '骂人at', '骂人通知', '禁言消息at', '删好友', '拉黑']
    let titleKey = ['defaultBotName', 'range', 'notice', 'curseAt', 'curseNotice', 'muteAt', 'deleteFriend', 'blackFriend']
    for (let i = 0; i < titleList.length; i++) {
      if (title == titleList[i]) {
        config.set(titleKey[i], value == '开启' ? true : false)
        break
      }
    }
    return await this.set(e)
  }

  async modify2(e) {
    if (!e.isMaster) {
      return false
    }
    let reg = new RegExp('#香菜(违禁词|全局违禁词|禁用群聊|全局群聊|私聊通行字符)(添加|删除)(.+)$')
    let title = reg.exec(e.msg)[1]
    let option = reg.exec(e.msg)[2]
    let value = reg.exec(e.msg)[3]
    let titleList = ['违禁词', '全局违禁词', '禁用群聊', '全局群聊', '私聊通行字符']
    let titleKey = ['arr', 'rangeArr', 'notGroup', 'rangeGroup', 'privateAdopt']
    let msg = [`${title}列表:\n`]
    for (let i = 0; i < titleList.length; i++) {
      if (title == titleList[i]) {
        if (i == 2 || i == 3) {
          value = Number(value)
        }
        if (option == '添加') {
          let arr = config.get(titleKey[i])
          if (Array.isArray(arr)) {
            arr.push(value)
          } else {
            arr = [value]
          }
          config.set(titleKey[i], arr)
        } else {
          let arr = config.get(titleKey[i])
          if (Array.isArray(arr)) {
            for (let j = 0; j < arr.length; j++) {
              if (arr[j] == value) {
                arr.splice(j, 1)
                config.set(titleKey[i], arr)
                break
              }
            }
          }
        }
        let arr = await this.getList(titleKey[i])
        if (Array.isArray(arr)) {
          msg.push(arr.join('\n'))
        } else {
          msg.push('无')
        }
        break
      }
    }
    e.reply(msg)
    return true
  }

  async modify3(e) {
    if (!e.isMaster) {
      return false
    }
    let reg = new RegExp('^#香菜设置(机器人名字|禁言消息|私聊消息)(.*)$')
    let title = reg.exec(e.msg)[1]
    let value = reg.exec(e.msg)[2]
    let titleList = ['机器人名字', '禁言消息', '私聊消息']
    let titleKey = ['botName', 'muteMsg', 'blackMsg']
    for (let i = 0; i < titleList.length; i++) {
      if (title == titleList[i]) {
        if (i == 0) {
          if (value == '') {
            value = '机器人'
          }
        } else {
          if (value == '空') {
            value = null
          }
        }
        config.set(titleKey[i], value)
        break
      }
    }
    return await this.set(e)
  }

  async modify4(e) {
    if (!e.isMaster) {
      return false
    }
    let reg = new RegExp('^#香菜设置(全局处理|处理|处理二|处理三|次数|私聊次数|骂人类型|骂人撤回|禁言时间|禁言消息撤回)([0-9]+)$')
    let title = reg.exec(e.msg)[1]
    let value = Number(reg.exec(e.msg)[2])
    let titleList = ['全局处理', '处理', '处理二', '处理三', '次数', '私聊次数', '骂人类型', '骂人撤回', '禁言时间', '禁言消息撤回']
    let titleKey = ['rangeType', 'type', 'type2', 'type3', 'num', 'privateNum', 'curseType', 'curseRecall', 'muteTime', 'muteRecall']
    let titleValue = [[1, 2, 3], [1, 2, 3, 4, 5], [0, 1, 2, 5], [0, 1, 2, 5], 0, 0, [1, 2], 0, 0, 0]
    for (let i = 0; i < titleList.length; i++) {
      if (title == titleList[i]) {
        if (Array.isArray(titleValue[i])) {
          if (titleValue[i].indexOf(value) > -1) {
            config.set(titleKey[i], value)
            break
          }
        } else {
          if (i == 7 || i == 9) {
            if (value >= 0 && value <= 120) {
              config.set(titleKey[i], value)
              break
            }
          } else {
            if (value > 0) {
              config.set(titleKey[i], value)
              break
            }
          }
        }
        break
      }
    }
    return await this.set(e)
  }


  async fuck(e) {
    //如果没有消息,比如图片
    if (!e.msg) {
      return false
    }
    let flag = true
    //是群聊 并且艾特bot或者提到了bot名字
    if ((e.atBot || (config.get('botName') ? e.msg.includes(config.get('botName')) : false)) || (config.get('defaultBotName') ? e.msg.includes('机器人') : false) && e.isGroup) {
      //如果是不用开启的群聊就return false
      if (config.get('notGroup')) {
        if (config.get('notGroup').some(item => item == e.group_id)) {
          return false
        }
      }
      //检测消息中是否包含违禁词
      if (config.get('arr')) {
        if (config.get('arr').some(item => e.msg.includes(item))) {
          return await this.main(e)
        }
      }
      flag = false
      //是私聊
    } else if (e.isPrivate) {

      //防止误杀
      if (config.get('privateAdopt').some(item => e.msg.indexOf(item) == -1 ? false : true)) {
        return false
      }
      //检测消息中是否包含违禁词
      if (config.get('arr').some(item => e.msg.includes(item))) {
        //私聊直接拉黑
        return await this.privateMethod(e)
      }
    }
    //检测全局消息 上面艾特了检测了一次如果没有就不用再检测了
    if (config.get('range') && flag) {
      //需要开启的群聊
      if (config.get('rangeGroup')) {
        if (config.get('rangeGroup').some(item => item == Number(e.group_id))) {
          if (config.get('rangeArr')) {
            //检测消息中是否包含违禁词
            if (config.get('rangeArr').some(item => e.msg.includes(item))) {
              return await this.rangeMethod(e)
            }
          }
        }
      }

    }
    //啥都没找到就return false 给别的插件处理
    return false
  }

  async privateMethod(e) {
    if (config.get('privateNum') <= 1) {
      //如果有要发送的消息
      if (config.get('blackMsg')) {
        e.reply(config.get('blackMsg').toString())
      }
      //如果通知主人
      if (config.get('notice')) {
        await common.sleep(500)
        let msg = [
          segment.image(`https://q1.qlogo.cn/g?b=qq&s=100&nk=${e.user_id}`),
          `检测到违禁词：${e.msg}\n`,
          `QQ号：${e.user_id}\n`,
          `QQ昵称：${e.nickname}\n`,
          `当前操作: 拉黑`
        ]
        await common.relpyPrivate(cfg.masterQQ[0], msg)
      }
      await this.blockqq(e)
      return true
    }
    let i = await redis.get(`Yunzai:fuck:private:${e.user_id}`)
    if (!i) {
      i = 1 * 1
      await e.reply(`监测到违规词汇，警告第${i}次`)
      await redis.set(`Yunzai:fuck:private:${e.user_id}`, i, { EX: 60 * 60 * 24 * 30 * 6 })
      //如果通知主人
      if (config.get('notice')) {
        await common.sleep(500)
        await this.relpyPrivate(e, '拉黑', i)
      }
    } else if (i >= config.get('privateNum') - 1) {
      //如果有要发送的消息
      if (config.get('blackMsg')) {
        e.reply(config.get('blackMsg').toString())
      }
      await this.blockqq(e, ++i)
      await redis.del(`Yunzai:fuck:private:${e.user_id}`)
      return true
    } else {
      i++
      await e.reply(`监测到违规词汇，警告第${i}次`)
      await redis.set(`Yunzai:fuck:private:${e.user_id}`, i, { EX: 60 * 60 * 24 * 30 * 6 })
      //如果通知主人
      if (config.get('notice')) {
        await common.sleep(500)
        await this.relpyPrivate(e, '拉黑', i)
      }
    }
    return true
  }

  //检测全局的处理方式
  async rangeMethod(e) {
    if (config.get('rangeType') == 1) {
      //是管理才行
      if (e.group.is_admin || e.group.is_owner) {
        //看一下对方是不是管理
        let Memberinfo = e.group.pickMember(Number(e.user_id)).info
        //如果对方是群主
        if (Memberinfo.role === 'owner') {
          return true
        }
        //如果对方是管理
        if (Memberinfo.role === 'admin') {
          //自己不是群主的话
          if (!e.group.is_owner) {
            return true
          }
        }
        //如果对方是群员那就禁言
        if (config.get('muteTime') > 0) {
          await e.group.muteMember(e.user_id, config.get('muteTime') * 60);
        }
        //如果有要发送的消息
        if (config.get('muteMsg')) {
          e.reply(config.get('muteMsg').toString(), false, { at: config.get('muteAt') ? true : false, recallMsg: config.get('muteRecall') })
        }
        //如果通知主人
        if (config.get('notice')) {
          await common.sleep(500)
          await this.relpyPrivate(e, '禁言')
        }
        return true
        //如果选择禁言但是自己不是管理
      } else {
        return true
      }
    } else if (config.get('rangeType') == 2) {
      //先看看自己是不是管理
      if (e.group.is_admin || e.group.is_owner) {
        //看看对方的身份
        let Memberinfo = e.group.pickMember(Number(e.user_id)).info
        //如果对方是群主
        if (Memberinfo.role === 'owner') {
          return true
        }
        //如果对方是管理
        if (Memberinfo.role === 'admin') {
          //如果自己不是群主
          if (!e.group.is_owner) {
            return true
          }
        }
        //给爷爬
        await this.kickGroup(e)
        return true
        //如果自己不是管理
      } else {
        return true
      }
    } else if (config.get('rangeType') == 3) {
      return await this.block(e)
    }
  }

  async main(e) {
    //警告,达到次数后退群
    if (config.get('type') == 1) {
      await this.quitGroup(e)
      return true
      //骂回去
    } else if (config.get('type') == 2) {
      await this.curseGroup(e)
      return true
      //禁言
    } else if (config.get('type') == 3) {
      //是管理才行
      if (e.group.is_admin || e.group.is_owner) {
        //看一下对方是不是管理
        let Memberinfo = e.group.pickMember(Number(e.user_id)).info
        //如果对方是群主
        if (Memberinfo.role === 'owner') {
          //那就退群吧
          if (config.get('type3') == 1) {
            await this.quitGroup(e)
            return true
            //那就骂回去吧
          } else if (config.get('type3') == 2) {
            await this.curseGroup(e)
            return true
            //那就算了吧
          } else {
            return false
          }
        }
        //如果对方是管理
        if (Memberinfo.role === 'admin') {
          //自己不是群主的话
          if (!e.group.is_owner) {
            //那就退群吧
            if (config.get('type3') == 1) {
              await this.quitGroup(e)
              return true
              //那就骂回去吧
            } else if (config.get('type3') == 2) {
              await this.curseGroup(e)
              return true
              //那就算了吧
            } else {
              return false
            }
          }
        }
        //如果对方是群员那就禁言
        if (config.get('muteTime') > 0) {
          await e.group.muteMember(e.user_id, config.get('muteTime') * 60);
        }
        //如果有要发送的消息
        if (config.get('muteMsg')) {
          e.reply(config.get('muteMsg').toString(), false, { at: config.get('muteAt') ? true : false, recallMsg: config.get('muteRecall') })
        }
        //如果通知主人
        if (config.get('notice')) {
          await common.sleep(500)
          await this.relpyPrivate(e, '禁言')
        }
        return true
        //如果选择禁言但是自己不是管理
      } else {
        //那就退群吧
        if (config.get('type2') == 1) {
          await this.quitGroup(e)
          return true
          //那就骂回去吧
        } else if (config.get('type2') == 2) {
          await this.curseGroup(e)
          return true
          //那就算了吧
        } else {
          return false
        }
      }
      //踢出群聊
    } else if (config.get('type') == 4) {
      //先看看自己是不是管理
      if (e.group.is_admin || e.group.is_owner) {
        //看看对方的身份
        let Memberinfo = e.group.pickMember(Number(e.user_id)).info
        //如果对方是群主
        if (Memberinfo.role === 'owner') {
          //那就退群吧
          if (config.get('type3') == 1) {
            await this.quitGroup(e)
            return true
            //那就骂回去吧
          } else if (config.get('type3') == 2) {
            await this.curseGroup(e)
            return true
            //那就算了吧
          } else {
            return false
          }
        }
        //如果对方是管理
        if (Memberinfo.role === 'admin') {
          //如果自己不是群主
          if (!e.group.is_owner) {
            //那就退群吧
            if (config.get('type3') == 1) {
              await this.quitGroup(e)
              return true
              //那就骂回去吧
            } else if (config.get('type3') == 2) {
              await this.curseGroup(e)
              return true
              //那就算了吧
            } else {
              return false
            }
          }
        }
        //给爷爬
        await this.kickGroup(e)
        return true
        //如果自己不是管理
      } else {
        //那就退群吧
        if (config.get('type2') == 1) {
          await this.quitGroup(e)
          return true
          //那就骂回去吧
        } else if (config.get('type2') == 2) {
          await this.curseGroup(e)
          return true
          //那就算了吧
        } else {
          return false
        }
      }
    } else if (config.get('type') == 5) {
      return await this.block(e)
    }
  }

  /**
   * 退群
   * @param {*} e 
   * @returns 
   */
  async quitGroup(e) {
    if (config.get('num') <= 1) {
      await e.reply(`监测到违规词汇，将进行退群处理`)
      await this.quit(e)
      return true
    }
    let i = await redis.get(`Yunzai:fuck:group:${e.group_id}`)
    if (!i) {
      i = 1 * 1
      await e.reply(`监测到违规词汇，警告第${i}次`)
      await redis.set(`Yunzai:fuck:group:${e.group_id}`, i, { EX: 60 * 60 * 24 * 30 * 6 })
    } else if (i >= config.get('num') - 1) {
      await e.reply(`监测到违规词汇次数达到${config.get('num')}次，将进行退群处理`)
      await this.quit(e, ++i)
      await redis.del(`Yunzai:fuck:group:${e.group_id}`)
      return true
    } else {
      i++
      await e.reply(`监测到违规词汇，警告第${i}次`)
      await redis.set(`Yunzai:fuck:group:${e.group_id}`, i, { EX: 60 * 60 * 24 * 30 * 6 })
    }
    if (config.get('notice')) {
      await common.sleep(500)
      await this.relpyPrivate(e, '退群', i)
    }
    return true
  }

  /**
   * 骂回去
   * @param {*} e 
   * @returns 
   */
  async curseGroup(e) {
    let msg
    if (config.get('curseType') == 1) {
      msg = await this.getGentle()
    } else if (config.get('curseType') == 2) {
      msg = await this.getViolent()
    } else {
      return false
    }
    e.reply(msg, false, { at: config.get('curseAt') ? true : false, recallMsg: config.get('curseRecall') })
    if (config.get('curseNotice')) {
      await common.sleep(500)
      await this.relpyPrivate(e, '骂回去')
    }
    return true
  }

  /**
   * 踢出群聊
   * @param {*} e 
   * @returns 
   */
  async kickGroup(e) {
    if (config.get('num') <= 1) {
      await e.reply(`监测到违规词汇，将进行踢群处理`)
      await this.kick(e)
      return true
    }
    let i = await redis.get(`Yunzai:fuck:group:${e.group_id}:qq:${e.user_id}`)
    if (!i) {
      i = 1 * 1
      await e.reply(`监测到违规词汇，警告第${i}次`)
      await redis.set(`Yunzai:fuck:group:${e.group_id}:qq:${e.user_id}`, i, { EX: 60 * 60 * 24 * 30 * 6 })
    } else if (i >= config.get('num') - 1) {
      await e.reply(`监测到违规词汇次数达到${config.get('num')}次，将进行踢群处理`)
      await this.kick(e, ++i)
      await redis.del(`Yunzai:fuck:group:${e.group_id}:qq:${e.user_id}`)
      return true
    } else {
      i++
      await e.reply(`监测到违规词汇，警告第${i}次`)
      await redis.set(`Yunzai:fuck:group:${e.group_id}:qq:${e.user_id}`, i, { EX: 60 * 60 * 24 * 30 * 6 })
    }
    if (config.get('notice')) {
      await common.sleep(500)
      await this.relpyPrivate(e, '踢群', i)
    }
    return true
  }


  /**
   * 拉黑
   * @param {*} e 
   * @returns 
   */
  async block(e) {
    if (config.get('num') <= 1) {
      await e.reply(`监测到违规词汇，将进行拉黑处理`)
      await this.blockqq(e)
      return true
    }
    let i = await redis.get(`Yunzai:fuck:group:${e.group_id}:qq:${e.user_id}`)
    if (!i) {
      i = 1 * 1
      await e.reply(`监测到违规词汇，警告第${i}次`)
      await redis.set(`Yunzai:fuck:group:${e.group_id}:qq:${e.user_id}`, i, { EX: 60 * 60 * 24 * 30 * 6 })
    } else if (i >= config.get('num') - 1) {
      await e.reply(`监测到违规词汇次数达到${config.get('num')}次，将进行拉黑处理`)
      await this.blockqq(e, ++i)
      await redis.del(`Yunzai:fuck:group:${e.group_id}:qq:${e.user_id}`)
      return true
    } else {
      i++
      await e.reply(`监测到违规词汇，警告第${i}次`)
      await redis.set(`Yunzai:fuck:group:${e.group_id}:qq:${e.user_id}`, i, { EX: 60 * 60 * 24 * 30 * 6 })
    }
    if (config.get('notice')) {

      await common.sleep(500)
      await this.relpyPrivate(e, '拉黑', i)
    }
    return true
  }

  /**
  * 达到次数之后通知主人是否退群成功
  * @param {*} e 
  * @param {*} i 次数
  */
  async quit(e, i = 1) {
    await common.sleep(500)
    await this.relpyPrivate(e, '退群', i)
    await common.sleep(500)
    await Bot.pickGroup(e.group_id).quit()
      .then(async () => {
        let msg = [
          segment.image(`https://p.qlogo.cn/gh/${e.group_id}/${e.group_id}/100`),
          `退群成功,群号:${e.group_id}\n`,
        ]
        if (config.get('blackFriend')) {
          let data = YAML.parseDocument(fs.readFileSync(this.otherPath, 'utf8'))
          let blackQQ = lodash.get(data.toJSON(), 'blackQQ')
          blackQQ.push(Number(e.user_id))
          data.setIn(['blackQQ'], blackQQ)
          let yaml = data.toString()
          fs.writeFileSync(this.otherPath, yaml, 'utf8')
          msg = [
            segment.image(`https://q1.qlogo.cn/g?b=qq&s=100&nk=${e.user_id}`),
            `拉黑成功,QQ:${e.user_id}\n`
          ]
        }
        if (config.get('deleteFriend')) {
          if (Bot.fl.get(Number(e.user_id))) {
            await Bot.pickFriend(e.user_id).delete()
              .then(() => {
                msg.push(`删除成功,QQ:${e.user_id}`)
              })
              .catch((err) => {
                msg.push(`删除失败,QQ:${e.user_id}`)
                console.log(err);
              })
          }
        }
        await common.relpyPrivate(cfg.masterQQ[0], msg)
      })
      .catch(async (err) => {
        let msg = [
          segment.image(`https://p.qlogo.cn/gh/${e.group_id}/${e.group_id}/100`),
          `退群失败,群号:${e.group_id}`,
        ]
        await common.relpyPrivate(cfg.masterQQ[0], msg)
        console.log(err)
      })
  }

  /**
   * 拉黑和删除指定qq
   * @param {*} e 
   * @returns 
   */
  async blockqq(e) {
    let data = YAML.parseDocument(fs.readFileSync(this.otherPath, 'utf8'))
    let blackQQ = lodash.get(data.toJSON(), 'blackQQ')
    blackQQ.push(Number(e.user_id))
    data.setIn(['blackQQ'], blackQQ)
    let yaml = data.toString()
    fs.writeFileSync(this.otherPath, yaml, 'utf8')
    let msg = [
      e.isGroup ? segment.image(`https://p.qlogo.cn/gh/${e.group_id}/${e.group_id}/100`) : '',
      e.isGroup ? `群号:${e.group_id}\n` : '',
      segment.image(`https://q1.qlogo.cn/g?b=qq&s=100&nk=${e.user_id}`),
      `拉黑成功,QQ:${e.user_id}\n`
    ]
    if (config.get('deleteFriend')) {
      if (e.isPrivate) {
        await Bot.pickFriend(e.user_id).delete()
          .then(() => {
            msg.push(`删除成功,QQ:${e.user_id}`)
          })
          .catch((err) => {
            msg.push(`删除失败,QQ:${e.user_id}`)
            console.log(err);
          })
      }
    }
    await common.relpyPrivate(cfg.masterQQ[0], msg)
    return true
  }


  /**
   * 通知主人
   * @param {*} e 
   * @param {*} t 当前操作
   * @param {*} i 次数
   */
  async relpyPrivate(e, t, i = 0) {
    let msg = [
      segment.image(`https://q1.qlogo.cn/g?b=qq&s=100&nk=${e.user_id}`),
      `检测到违禁词：${e.msg}\n`,
      i ? `次数: ${i}\n` : '',
      e.isGroup ? `群号：${e.group_id}\n` : '',
      e.isGroup ? `群聊名称: ${e.group_name}\n` : '',
      `QQ号：${e.user_id}\n`,
      `QQ昵称：${e.nickname}\n`,
      `当前操作: ${t}`
    ]
    await common.relpyPrivate(cfg.masterQQ[0], msg)
  }

  /**
   * 达到次数之后通知主人是否踢群成功
   * @param {\} e 
   * @param {*} i 次数
   */
  async kick(e, i = 1) {
    await common.sleep(500)
    await this.relpyPrivate(e, '踢群', i)
    await common.sleep(500)
    let res = await e.group.kickMember(Number(e.user_id))
    if (res) {
      let msg = [
        segment.image(`https://p.qlogo.cn/gh/${e.group_id}/${e.group_id}/100`),
        `踢群成功,群号:${e.group_id}\n`,
        segment.image(`https://q1.qlogo.cn/g?b=qq&s=100&nk=${e.user_id}`),
        `QQ:${e.user_id}\n`
      ]
      if (config.get('blackFriend')) {
        let data = YAML.parseDocument(fs.readFileSync(this.otherPath, 'utf8'))
        let blackQQ = lodash.get(data.toJSON(), 'blackQQ')
        blackQQ.push(Number(e.user_id))
        data.setIn(['blackQQ'], blackQQ)
        let yaml = data.toString()
        fs.writeFileSync(this.otherPath, yaml, 'utf8')
        msg.push(
          `拉黑成功,QQ:${e.user_id}\n`
        )
      }
      if (config.get('deleteFriend')) {
        if (Bot.fl.get(Number(e.user_id))) {
          await Bot.pickFriend(e.user_id).delete()
            .then(() => {
              msg.push(`删除成功,QQ:${e.user_id}`)
            })
            .catch((err) => {
              msg.push(`删除失败,QQ:${e.user_id}`)
              console.log(err);
            })
        }
      }
      await common.relpyPrivate(cfg.masterQQ[0], msg)
    } else {
      let msg = [
        segment.image(`https://p.qlogo.cn/gh/${e.group_id}/${e.group_id}/100`),
        `踢群失败,群号:${e.group_id}\n`,
        segment.image(`https://q1.qlogo.cn/g?b=qq&s=100&nk=${e.user_id}`),
        `QQ:${e.user_id}`
      ]
      await common.relpyPrivate(cfg.masterQQ[0], msg)
    }
  }

  async getSetList() {
    const SetList =
      [
        {
          "title": "#香菜查询群次数12345",
          "value": "o(*////▽////*)q",
          "desc": "查看某个群触发了多少次"
        },
        {
          "title": "#香菜清除群次数123456",
          "value": "o(*////▽////*)q",
          "desc": "把某个群的次数重置为0"
        },
        {
          "title": "#香菜违禁词(添加/删除)xxx",
          "value": "o(*////▽////*)q",
          "desc": "违禁词列表添加或删除 可使用#香菜违禁词列表 来查看"
        },
        {
          "title": "#香菜设置机器人名字xxx",
          "value": config.get('botName'),
          "desc": "设置机器人名字 聊天过程中提到机器人名字和违禁词就会警告"
        },
        {
          "title": "#香菜禁用群聊(添加/删除)xxx",
          "value": "o(*////▽////*)q",
          "desc": "不需要开启的群聊 可使用#香菜禁用群聊列表 来查看"
        },
        {
          "title": "#香菜设置默认名字(开启/关闭)",
          "value": config.get('defaultBotName') ? '开启' : '关闭',
          "desc": "设置机器人名字后是否检测'机器人'这个词 比如sb机器人是否检测"
        },
        {
          "title": "#香菜设置全局(开启/关闭)",
          "value": config.get('range') ? '开启' : '关闭',
          "desc": "是否检测全部消息 不带机器人名字也会检测"
        },
        {
          "title": "#香菜设置全局处理(1/2/3)",
          "value": config.get('rangeType'),
          "desc": "检测全部消息的处理方式 1:禁言 2:达到次数出群聊 3:达到次数拉黑"
        },
        {
          "title": "#香菜全局违禁词(添加/删除)xxx",
          "value": "o(*////▽////*)q",
          "desc": "全局违禁词列表添加或删除 可使用#香菜全局违禁词列表 来查看"
        },
        {
          "title": "#香菜全局群聊(添加/删除)xxx",
          "value": "o(*////▽////*)q",
          "desc": "检测所有消息时需要开启的群聊 可使用#香菜全局群聊列表 来查看"
        },
        {
          "title": "#香菜设置处理(1/2/3/4/5)",
          "value": config.get('type'),
          "desc": "被骂之后怎么处理  1:警告,达到次数之后退群 2:骂回去 3:禁言 4:警告,达到次数后踢出群聊 5:达到次数后拉黑"
        },
        {
          "title": "#香菜设置处理二(0/1/2/5)",
          "value": config.get('type2'),
          "desc": "如果选择3:禁言和4:踢群之后不是管理员就执行这个,或者填0不进行处理"
        },
        {
          "title": "#香菜设置处理三(0/1/2/5)",
          "value": config.get('type3'),
          "desc": "#如果选择3:禁言和4:踢群之后对方也是管理或者群主就执行这个,或者填0不进行处理"
        },
        {
          "title": "#香菜设置通知(开启/关闭)",
          "value": config.get('notice') ? '开启' : '关闭',
          "desc": "被骂之后是否通知主人,如果有多个主人会通知第一个主人"
        },
        {
          "title": "#香菜设置次数xxx",
          "value": config.get('num'),
          "desc": "选择1退群,4踢群,5拉黑时,达到多少次进行操作"
        },
        {
          "title": "#香菜设置骂人类型(1/2)",
          "value": config.get('curseType'),
          "desc": "选择2骂回去时,骂回去的类型 1:温柔模式 2:暴力模式(慎用,后果自负)"
        },
        {
          "title": "#香菜设置骂人at(开启/关闭)",
          "value": config.get('curseAt') ? '开启' : '关闭',
          "desc": "选择2骂回去时,是否at触发者"
        },
        {
          "title": "#香菜设置骂人撤回(0-120)",
          "value": config.get('curseRecall'),
          "desc": "选择2骂回去时,是否撤回消息 0-120,单位为秒,为0则不撤回"
        },
        {
          "title": "#香菜设置骂人通知(开启/关闭)",
          "value": config.get('curseNotice') ? '开启' : '关闭',
          "desc": "选择2骂回去时,是否通知主人"
        },
        {
          "title": "#香菜设置禁言时间xxx",
          "value": config.get('muteTime'),
          "desc": "选择3禁言时,禁言时间 单位:分钟"
        },
        {
          "title": "#香菜设置禁言消息xxx",
          "value": config.get('muteMsg') || "o(*////▽////*)q",
          "desc": "选择3禁言时,发送的文字 为空则不发送"
        },
        {
          "title": "#香菜设置禁言消息撤回(0-120)",
          "value": config.get('muteRecall'),
          "desc": "选择3禁言时,如果有发送的文字,那么文字是否撤回,0-120,单位为秒,为0则不撤回"
        },
        {
          "title": "#香菜设置禁言消息at(开启/关闭)",
          "value": config.get('muteAt') ? '开启' : '关闭',
          "desc": "选择3禁言时,如果有发送的文字,那么文字是否at"
        },
        {
          "title": "#香菜设置私聊次数xxx",
          "value": config.get('privateNum'),
          "desc": "私聊被骂时达到多少次拉黑"
        },
        {
          "title": "#香菜设置私聊消息xxx",
          "value": config.get('blackMsg') || "o(*////▽////*)q",
          "desc": "私聊被骂时,发送的文字 为空则不发送直接拉黑"
        },
        {
          "title": "#香菜设置删好友(开启/关闭)",
          "value": config.get('deleteFriend') ? '开启' : '关闭',
          "desc": "私聊被骂时以及1退群和4踢群时是否删触发者的好友(删除的是最后一次触发的那个人)"
        },
        {
          "title": "#香菜设置拉黑(开启/关闭)",
          "value": config.get('blackFriend') ? '开启' : '关闭',
          "desc": "选择1退群和4踢群时是否拉黑触发者(拉黑的是最后一次触发的那个人)"
        },
        {
          "title": "#香菜私聊通行字符(添加/删除)xxx",
          "value": "o(*////▽////*)q",
          "desc": "私聊通行字符 防止误杀 可使用#香菜通行字符列表 来查看"
        },
      ]

    return SetList
  }

  /* 获得温柔的词汇 */
  async getGentle() {
    return '再给次机会啦阿sir'
  }

  /* 获得暴力的词汇 */
  async getViolent() {
    return '再给次机会啦阿sir'
  }
}

async function init() {
  //检查有没有resources/xiangcai这个目录
  let tempPath = path + '/resources/xiangcai'
  if (!fs.existsSync(tempPath)) {
    fs.mkdirSync(tempPath, (err) => {
      if (err) {
        console.error(err);
      }
    })
    let msg = '感谢使用本js插件,插件功能为检测到骂机器人就进行处理,也可以检测所有消息,当全局违禁词使用\n' +
      '另外本插件没有做主人判断,如果不幸被自己机器人拉黑,可以前往Yunzai-Bot/config/config/other.yaml这个文件中找到最后的' +
      '#黑名单qq blackQQ删除自己的qq就行\n' +
      '如果对本插件的使用有问题可以来群154687817反馈'
    await common.relpyPrivate(cfg.masterQQ[0], msg)
  }
  //检查有没有resources/xiangcai/config.yaml
  let configPath = tempPath + '/config.yaml'
  if (!fs.existsSync(configPath)) {
    let data = `#违禁词
arr: 
  - 再给次机会啦阿sir

#机器人名字
botName: 机器人

#不需要开启的群聊
notGroup: 
  - 123456
  - 654321

#设置机器人名字后机器人名字是否自带 '机器人' 比如发送sb机器人 是否检测 false:不检测 true:检测
defaultBotName: false

#是否开启检测群聊所有消息 false:关闭 true:开启
range: false 

#检测全局处理方式 1:禁言 2:达到次数后踢出群聊 3:达到次数后拉黑
rangeType: 1

#全局违禁词
rangeArr: 
  - 再给次机会啦阿sir 

#如果选择开启检测全局时需要开启的群聊 不需要开启的群聊>需要开启的群聊 如果都填了就不会开启
rangeGroup: 
  - 123456
  - 654321 
    
#被骂之后怎么处理  1:警告,达到次数之后退群 2:骂回去 3:禁言 4:警告,达到次数后踢出群聊 5:达到次数后拉黑
type: 1  

#如果选择3和4之后不是管理员就执行这个,或者填0不进行处理
type2: 1 

#如果选择3和4之后对方也是管理或者群主就执行这个,或者填0不进行处理
type3: 0 
    
#选择1,3,4,5时,被骂之后是否通知主人 false:不通知 true:通知
notice: true 

#选择1退群,4踢群,5拉黑时,达到多少次退群或者踢出群聊
num: 3 

#选择2骂回去时,骂回去的类型 1:温柔模式 2:暴力模式(慎用!!!)(慎用!!!)(慎用!!!)(后果自负)  词汇在结尾可以自行查看或修改,未做细致的统计
curseType: 1

#选择2骂回去时,是否at false:不at true:at
curseAt: false 

#选择2骂回去时,是否撤回,0-120,单位为秒,为0则不撤回
curseRecall: 0 

#选择2骂回去时,是否通知主人 false:不通知 true:通知
curseNotice: true

#选择3禁言时,禁言时间 单位:分钟
muteTime: 5 

#选择3禁言时,发送的文字 为空则不发送
muteMsg:  

#选择3禁言时,如果有发送的文字,那么文字是否撤回,0-120,单位为秒,为0则不撤回
muteRecall: 0 

#选择3禁言时,如果有发送的文字,那么文字是否at false:不at true:at
muteAt: false 

#私聊被骂次数达到多少次拉黑
privateNum: 1

#私聊被骂时,发送的文字 为空则不发送直接拉黑
blackMsg: 

#私聊被骂时,以及1退群和4踢群时是否删触发者的好友 false:不删除 true:删除
deleteFriend: true 

#选择1退群和4踢群时是否拉黑触发者 false:不拉黑 true:拉黑
blackFriend: true 
    
#私聊通行字符串 建议不改 或者有遗漏的自己加 防止误杀
privateAdopt: 
  - https://
  - stuid
  - ltoken
  - ltuid
  - stoken
  - cookie
`
    fs.writeFileSync(configPath, data, (err) => {
      if (err) {
        console.error(err);
      }
    }
    )
  }
  //检查有没有resources/xiangcai/config.js
  let jsPath = tempPath + '/config.js'
  if (!fs.existsSync(jsPath)) {
    let data = `import fs from 'fs'
import YAML from 'yaml'
import lodash from 'lodash'
import chokidar from 'chokidar'

export default class YamlReader {
  /**
   * 读写yaml文件
   *
   * @param yamlPath yaml文件绝对路径
   * @param isWatch 是否监听文件变化
   */
  constructor(yamlPath, isWatch = false) {
    this.yamlPath = yamlPath
    this.isWatch = isWatch
    this.initYaml()
  }

  initYaml() {
    try {
      // parseDocument 将会保留注释
      this.document = YAML.parseDocument(fs.readFileSync(this.yamlPath, 'utf8'))
    } catch (error) {
      throw error
    }
    if (this.isWatch && !this.watcher) {
      this.watcher = chokidar.watch(this.yamlPath).on('change', () => {
        if (this.isSave) {
          this.isSave = false
          return
        }
        this.initYaml()
      })
    }
  }

  /**返回读取的对象 */
  get jsonData() {
    if (!this.document) {
      return null
    }
    return this.document.toJSON()
  }

  /*检查集合是否包含key的值*/
  has(keyPath) {
    return this.document.hasIn(keyPath.split('.'))
  }
  /*返回key的值*/
  get(keyPath) {
    return lodash.get(this.jsonData, keyPath)
  }
  /*修改某个key的值*/
  set(keyPath, value) {
    this.document.setIn(keyPath.split('.'), value)
    this.save()
  }
  /*删除key*/
  delete(keyPath) {
    this.document.deleteIn(keyPath.split('.'))
    this.save()
  }
  //数组添加数据
  addIn(keyPath, value) {
    this.document.addIn(keyPath.split('.'), value)
    this.save()
  }
  /**
   * 设置 document 的数据（递归式）
   * @param data 要写入的数据
   */
  setData(data) {
    this.setDataRecursion(data, [])
    this.save()
  }

  setDataRecursion(data, parentKeys) {
    if (Array.isArray(data)) {
      this.document.setIn(this.mapParentKeys(parentKeys), data)
    } else if (typeof data === 'object' && data !== null) {
      for (const [key, value] of Object.entries(data)) {
        this.setDataRecursion(value, parentKeys.concat([key]))
      }
    } else {
      parentKeys = this.mapParentKeys(parentKeys)
      this.document.setIn(parentKeys, data)
    }
  }

  // 将数字key转为number类型，防止出现引号
  mapParentKeys(parentKeys) {
    return parentKeys.map((k) => {
      if (k.startsWith(Constant.CONFIG_INTEGER_KEY)) {
        return Number.parseInt(k.replace(Constant.CONFIG_INTEGER_KEY, ''))
      }
      return k
    })
  }

  // 彻底删除某个key
  deleteKey(keyPath) {
    let keys = keyPath.split('.')
    keys = this.mapParentKeys(keys)
    this.document.deleteIn(keys)
    this.save()
  }

  save() {
    this.isSave = true
    let yaml = this.document.toString()
    fs.writeFileSync(this.yamlPath, yaml, 'utf8')
  }
}`

    fs.writeFileSync(jsPath, data, (err) => {
      if (err) {
        console.error(err);
      }
    }
    )
  }
  //检查有没有resources/xiangcai/set.html
  let setHtmlPath = tempPath + '/set.html'
  if (!fs.existsSync(setHtmlPath)) {
    let data = `<!DOCTYPE html>
    <html lang="zh-cn">
    
    <head>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width">
        <link rel="shortcut icon" href="#" />
        <title></title>
        <style>
            .property-list {
                /* Content is center horizontally */
                align-items: center;
                display: flex;
    
                border-bottom: 1px solid #d1d5db;
    
                /* Spacing */
                margin: 0;
                padding: 0.25rem 0;
    
                font-weight: bold;
            }
    
            .property-list__key {
                /* Take the available width */
                flex: 1;
                margin-left: 40px;
                font-size: 23px;
            }
    
            .property-list__value {
                margin-left: 0.5rem;
                margin-right: 40px;
                font-size: 23px;
                font-weight: bold;
                width: 250px;
                text-align: right;
            }
    
            .property-list__description {
                margin-left: 40px;
                margin-right: 40px;
                font-size: 23px;
            }
    
            .item {
                padding-top: 10px;
                padding-bottom: 10px;
                margin-left: 40px;
                border: 1px solid red;
                background-color: rgba(255, 255, 255, 0.6);
                border-radius: 25px;
                margin-bottom: 20px;
                width: 700px;
            }
    
            .body {
                padding-top: 60px;
                padding-bottom: 40px;
                background: url({{pluResPath}}/resources/xiangcai/bg.png) no-repeat;
                background-color: rgb(1, 0, 66);
            }
    
    
            .header {
                margin-left: 40px;
                font-size: 40px;
            }
    
            .title,
            .tip {
                margin-bottom: 20px;
                margin: 0;
                padding-bottom: 20px;
            }
    
            .foot {
                margin-top: 22px;
                text-align: center;
                font-size: 25px;
                font-weight: bold;
                color: white;
            }
        </style>
    </head>
    
    <body>
        <div class="body">
            <div class="header">
                <h1 class="title">香菜设置/帮助</h1>
                <h6 class="tip">遇到问题可加群154687817反馈</h6>
            </div>
            {{each setList list}}
            <div class="item">
                <!-- A property item -->
                <dl class="property-list">
                    <!-- Property name -->
                    <dt class="property-list__key">{{list.title}}</dt>
    
                    <!-- Property value -->
                    <dd class="property-list__value">{{list.value}}</dd>
    
                    <!-- Property description -->
                </dl>
                <div class="property-list__description">{{list.desc}}</div>
            </div>
            {{/each}}
            <div class="foot">
                Created By Yunzai-Bot 3.0.0 & xiangcai.js {{version}}
            </div>
        </div>
    </body>
    
    </html>`

    fs.writeFileSync(setHtmlPath, data, (err) => {
      if (err) {
        console.error(err);
      }
    }
    )
  }

  //检查有没有resources/xiangcai/getBg.html
  let getBgPath = tempPath + '/getBg.html'
  if (!fs.existsSync(getBgPath)) {
    let data = `<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <img src="https://i.imgtg.com/2023/02/21/siT6G.png" alt="">
</body>

</html>`

    fs.writeFileSync(getBgPath, data, (err) => {
      if (err) {
        console.error(err);
      }
    }
    )
  }

  //检查有没有resources/xiangcai/bg.png
  let bgPath = tempPath + '/bg.png'
  if (!fs.existsSync(bgPath)) {
    let img = await puppeteer.screenshot('help', {
      tplFile: path + '/resources/xiangcai/getBg.html',
      pluResPath: path,
      imgType: 'png',
      quality: 100,
      omitBackground: true
    })
    fs.writeFileSync(bgPath, img.file, (err) => {
      if (err) {
        console.error(err);
      }
    })

  }
  return true
}

async function checkVersion() {
  //1.7 增加全局违禁词
  if (typeof config.get('rangeArr') == 'undefined') {
    let tempPath = path + '/resources/xiangcai'
    let configPath = tempPath + '/config.yaml'
    let data = fs.readFileSync(configPath, 'utf-8')
    let reg = new RegExp('range: (.*)')
    data = data.replace(reg,
      `range: ${reg.exec(data)[1]}
  
#检测全局处理方式 1:禁言 2:达到次数后踢出群聊 3:达到次数后拉黑
rangeType: 1
      
#全局违禁词
rangeArr: 
  - 再给次机会啦阿sir`
    )
    fs.writeFileSync(configPath, data, (err) => {
      if (err) {
        console.error(err);
      }
    })
    let setHtmlPath = tempPath + '/set.html'
    let html = fs.readFileSync(setHtmlPath, 'utf-8')
    html = html.replace(new RegExp('Created By Yunzai-Bot 3.0.0 & xiangcai.js (.*)'), 'Created By Yunzai-Bot 3.0.0 & xiangcai.js {{version}}')
    fs.writeFileSync(setHtmlPath, html, (err) => {
      if (err) {
        console.error(err);
      }
    }
    )
    let msg = '感谢使用本js插件,插件功能为检测到骂机器人就进行处理,也可以检测所有消息,当全局违禁词使用\n' +
      '另外本插件没有做主人判断,如果不幸被自己机器人拉黑,可以前往Yunzai-Bot/config/config/other.yaml这个文件中找到最后的' +
      '#黑名单qq blackQQ删除自己的qq就行\n' +
      '如果对本插件的使用有问题可以来群154687817反馈'
    await common.relpyPrivate(cfg.masterQQ[0], msg)

  }
  //1.8增加私聊次数
  if (typeof config.get('privateNum') == 'undefined') {
    let tempPath = path + '/resources/xiangcai'
    let configPath = tempPath + '/config.yaml'
    let data = fs.readFileSync(configPath, 'utf-8')
    let reg = new RegExp('muteAt: (.*)')
    data = data.replace(reg,
      `muteAt: ${reg.exec(data)[1]}
  
#私聊被骂次数达到多少次拉黑
privateNum: 1`
    )
    fs.writeFileSync(configPath, data, (err) => {
      if (err) {
        console.error(err);
      }
    })
  }
}

